home *** CD-ROM | disk | FTP | other *** search
/ PC go! 2018 July / PCgo 07-2018 CD-ROM Germany.iso / nw.pak / Unnamed File 004904.txt < prev    next >
Encoding:
Text File  |  2015-07-29  |  52.9 KB  |  1,501 lines
  1. // Copyright 2014 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4.  
  5. define("device/serial/serial.mojom", [
  6.     "mojo/public/js/bindings",
  7.     "mojo/public/js/codec",
  8.     "mojo/public/js/connection",
  9.     "mojo/public/js/core",
  10.     "mojo/public/js/validator",
  11.     "device/serial/data_stream.mojom",
  12. ], function(bindings, codec, connection, core, validator, data_stream) {
  13.   var SendError = {};
  14.   SendError.NONE = 0;
  15.   SendError.DISCONNECTED = SendError.NONE + 1;
  16.   SendError.PENDING = SendError.DISCONNECTED + 1;
  17.   SendError.TIMEOUT = SendError.PENDING + 1;
  18.   SendError.SYSTEM_ERROR = SendError.TIMEOUT + 1;
  19.   var ReceiveError = {};
  20.   ReceiveError.NONE = 0;
  21.   ReceiveError.DISCONNECTED = ReceiveError.NONE + 1;
  22.   ReceiveError.TIMEOUT = ReceiveError.DISCONNECTED + 1;
  23.   ReceiveError.DEVICE_LOST = ReceiveError.TIMEOUT + 1;
  24.   ReceiveError.SYSTEM_ERROR = ReceiveError.DEVICE_LOST + 1;
  25.   var DataBits = {};
  26.   DataBits.NONE = 0;
  27.   DataBits.SEVEN = DataBits.NONE + 1;
  28.   DataBits.EIGHT = DataBits.SEVEN + 1;
  29.   var ParityBit = {};
  30.   ParityBit.NONE = 0;
  31.   ParityBit.NO = ParityBit.NONE + 1;
  32.   ParityBit.ODD = ParityBit.NO + 1;
  33.   ParityBit.EVEN = ParityBit.ODD + 1;
  34.   var StopBits = {};
  35.   StopBits.NONE = 0;
  36.   StopBits.ONE = StopBits.NONE + 1;
  37.   StopBits.TWO = StopBits.ONE + 1;
  38.  
  39.   function DeviceInfo(values) {
  40.     this.initDefaults_();
  41.     this.initFields_(values);
  42.   }
  43.  
  44.  
  45.   DeviceInfo.prototype.initDefaults_ = function() {
  46.     this.path = null;
  47.     this.vendor_id = 0;
  48.     this.has_vendor_id = false;
  49.     this.has_product_id = false;
  50.     this.product_id = 0;
  51.     this.display_name = null;
  52.   };
  53.   DeviceInfo.prototype.initFields_ = function(fields) {
  54.     for(var field in fields) {
  55.         if (this.hasOwnProperty(field))
  56.           this[field] = fields[field];
  57.     }
  58.   };
  59.  
  60.   DeviceInfo.validate = function(messageValidator, offset) {
  61.     var err;
  62.  
  63.     err = messageValidator.validateStructHeader(offset, DeviceInfo.encodedSize, 6);
  64.     if (err !== validator.validationError.NONE)
  65.         return err;
  66.     // validate DeviceInfo.path
  67.     err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 0, false)
  68.     if (err !== validator.validationError.NONE)
  69.         return err;
  70.     // validate DeviceInfo.display_name
  71.     err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 16, true)
  72.     if (err !== validator.validationError.NONE)
  73.         return err;
  74.  
  75.     return validator.validationError.NONE;
  76.   };
  77.  
  78.   DeviceInfo.encodedSize = codec.kStructHeaderSize + 24;
  79.  
  80.   DeviceInfo.decode = function(decoder) {
  81.     var packed;
  82.     var val = new DeviceInfo();
  83.     var numberOfBytes = decoder.readUint32();
  84.     var numberOfFields = decoder.readUint32();
  85.     val.path = decoder.decodeStruct(codec.String);
  86.     val.vendor_id = decoder.decodeStruct(codec.Uint16);
  87.     packed = decoder.readUint8();
  88.     val.has_vendor_id = (packed >> 0) & 1 ? true : false;
  89.     val.has_product_id = (packed >> 1) & 1 ? true : false;
  90.     decoder.skip(1);
  91.     val.product_id = decoder.decodeStruct(codec.Uint16);
  92.     decoder.skip(1);
  93.     decoder.skip(1);
  94.     val.display_name = decoder.decodeStruct(codec.NullableString);
  95.     return val;
  96.   };
  97.  
  98.   DeviceInfo.encode = function(encoder, val) {
  99.     var packed;
  100.     encoder.writeUint32(DeviceInfo.encodedSize);
  101.     encoder.writeUint32(6);
  102.     encoder.encodeStruct(codec.String, val.path);
  103.     encoder.encodeStruct(codec.Uint16, val.vendor_id);
  104.     packed = 0;
  105.     packed |= (val.has_vendor_id & 1) << 0
  106.     packed |= (val.has_product_id & 1) << 1
  107.     encoder.writeUint8(packed);
  108.     encoder.skip(1);
  109.     encoder.encodeStruct(codec.Uint16, val.product_id);
  110.     encoder.skip(1);
  111.     encoder.skip(1);
  112.     encoder.encodeStruct(codec.NullableString, val.display_name);
  113.   };
  114.  
  115.   function ConnectionOptions(values) {
  116.     this.initDefaults_();
  117.     this.initFields_(values);
  118.   }
  119.  
  120.  
  121.   ConnectionOptions.prototype.initDefaults_ = function() {
  122.     this.bitrate = 0;
  123.     this.data_bits = DataBits.NONE;
  124.     this.parity_bit = ParityBit.NONE;
  125.     this.stop_bits = StopBits.NONE;
  126.     this.cts_flow_control = false;
  127.     this.has_cts_flow_control = false;
  128.   };
  129.   ConnectionOptions.prototype.initFields_ = function(fields) {
  130.     for(var field in fields) {
  131.         if (this.hasOwnProperty(field))
  132.           this[field] = fields[field];
  133.     }
  134.   };
  135.  
  136.   ConnectionOptions.validate = function(messageValidator, offset) {
  137.     var err;
  138.  
  139.     err = messageValidator.validateStructHeader(offset, ConnectionOptions.encodedSize, 6);
  140.     if (err !== validator.validationError.NONE)
  141.         return err;
  142.  
  143.     return validator.validationError.NONE;
  144.   };
  145.  
  146.   ConnectionOptions.encodedSize = codec.kStructHeaderSize + 24;
  147.  
  148.   ConnectionOptions.decode = function(decoder) {
  149.     var packed;
  150.     var val = new ConnectionOptions();
  151.     var numberOfBytes = decoder.readUint32();
  152.     var numberOfFields = decoder.readUint32();
  153.     val.bitrate = decoder.decodeStruct(codec.Uint32);
  154.     val.data_bits = decoder.decodeStruct(codec.Int32);
  155.     val.parity_bit = decoder.decodeStruct(codec.Int32);
  156.     val.stop_bits = decoder.decodeStruct(codec.Int32);
  157.     packed = decoder.readUint8();
  158.     val.cts_flow_control = (packed >> 0) & 1 ? true : false;
  159.     val.has_cts_flow_control = (packed >> 1) & 1 ? true : false;
  160.     decoder.skip(1);
  161.     decoder.skip(1);
  162.     decoder.skip(1);
  163.     decoder.skip(1);
  164.     decoder.skip(1);
  165.     decoder.skip(1);
  166.     decoder.skip(1);
  167.     return val;
  168.   };
  169.  
  170.   ConnectionOptions.encode = function(encoder, val) {
  171.     var packed;
  172.     encoder.writeUint32(ConnectionOptions.encodedSize);
  173.     encoder.writeUint32(6);
  174.     encoder.encodeStruct(codec.Uint32, val.bitrate);
  175.     encoder.encodeStruct(codec.Int32, val.data_bits);
  176.     encoder.encodeStruct(codec.Int32, val.parity_bit);
  177.     encoder.encodeStruct(codec.Int32, val.stop_bits);
  178.     packed = 0;
  179.     packed |= (val.cts_flow_control & 1) << 0
  180.     packed |= (val.has_cts_flow_control & 1) << 1
  181.     encoder.writeUint8(packed);
  182.     encoder.skip(1);
  183.     encoder.skip(1);
  184.     encoder.skip(1);
  185.     encoder.skip(1);
  186.     encoder.skip(1);
  187.     encoder.skip(1);
  188.     encoder.skip(1);
  189.   };
  190.  
  191.   function ConnectionInfo(values) {
  192.     this.initDefaults_();
  193.     this.initFields_(values);
  194.   }
  195.  
  196.  
  197.   ConnectionInfo.prototype.initDefaults_ = function() {
  198.     this.bitrate = 0;
  199.     this.data_bits = DataBits.NONE;
  200.     this.parity_bit = ParityBit.NONE;
  201.     this.stop_bits = StopBits.NONE;
  202.     this.cts_flow_control = false;
  203.   };
  204.   ConnectionInfo.prototype.initFields_ = function(fields) {
  205.     for(var field in fields) {
  206.         if (this.hasOwnProperty(field))
  207.           this[field] = fields[field];
  208.     }
  209.   };
  210.  
  211.   ConnectionInfo.validate = function(messageValidator, offset) {
  212.     var err;
  213.  
  214.     err = messageValidator.validateStructHeader(offset, ConnectionInfo.encodedSize, 5);
  215.     if (err !== validator.validationError.NONE)
  216.         return err;
  217.  
  218.     return validator.validationError.NONE;
  219.   };
  220.  
  221.   ConnectionInfo.encodedSize = codec.kStructHeaderSize + 24;
  222.  
  223.   ConnectionInfo.decode = function(decoder) {
  224.     var packed;
  225.     var val = new ConnectionInfo();
  226.     var numberOfBytes = decoder.readUint32();
  227.     var numberOfFields = decoder.readUint32();
  228.     val.bitrate = decoder.decodeStruct(codec.Uint32);
  229.     val.data_bits = decoder.decodeStruct(codec.Int32);
  230.     val.parity_bit = decoder.decodeStruct(codec.Int32);
  231.     val.stop_bits = decoder.decodeStruct(codec.Int32);
  232.     val.cts_flow_control = decoder.decodeStruct(codec.Uint8);
  233.     decoder.skip(1);
  234.     decoder.skip(1);
  235.     decoder.skip(1);
  236.     decoder.skip(1);
  237.     decoder.skip(1);
  238.     decoder.skip(1);
  239.     decoder.skip(1);
  240.     return val;
  241.   };
  242.  
  243.   ConnectionInfo.encode = function(encoder, val) {
  244.     var packed;
  245.     encoder.writeUint32(ConnectionInfo.encodedSize);
  246.     encoder.writeUint32(5);
  247.     encoder.encodeStruct(codec.Uint32, val.bitrate);
  248.     encoder.encodeStruct(codec.Int32, val.data_bits);
  249.     encoder.encodeStruct(codec.Int32, val.parity_bit);
  250.     encoder.encodeStruct(codec.Int32, val.stop_bits);
  251.     encoder.encodeStruct(codec.Uint8, val.cts_flow_control);
  252.     encoder.skip(1);
  253.     encoder.skip(1);
  254.     encoder.skip(1);
  255.     encoder.skip(1);
  256.     encoder.skip(1);
  257.     encoder.skip(1);
  258.     encoder.skip(1);
  259.   };
  260.  
  261.   function HostControlSignals(values) {
  262.     this.initDefaults_();
  263.     this.initFields_(values);
  264.   }
  265.  
  266.  
  267.   HostControlSignals.prototype.initDefaults_ = function() {
  268.     this.dtr = false;
  269.     this.has_dtr = false;
  270.     this.rts = false;
  271.     this.has_rts = false;
  272.   };
  273.   HostControlSignals.prototype.initFields_ = function(fields) {
  274.     for(var field in fields) {
  275.         if (this.hasOwnProperty(field))
  276.           this[field] = fields[field];
  277.     }
  278.   };
  279.  
  280.   HostControlSignals.validate = function(messageValidator, offset) {
  281.     var err;
  282.  
  283.     err = messageValidator.validateStructHeader(offset, HostControlSignals.encodedSize, 4);
  284.     if (err !== validator.validationError.NONE)
  285.         return err;
  286.  
  287.     return validator.validationError.NONE;
  288.   };
  289.  
  290.   HostControlSignals.encodedSize = codec.kStructHeaderSize + 8;
  291.  
  292.   HostControlSignals.decode = function(decoder) {
  293.     var packed;
  294.     var val = new HostControlSignals();
  295.     var numberOfBytes = decoder.readUint32();
  296.     var numberOfFields = decoder.readUint32();
  297.     packed = decoder.readUint8();
  298.     val.dtr = (packed >> 0) & 1 ? true : false;
  299.     val.has_dtr = (packed >> 1) & 1 ? true : false;
  300.     val.rts = (packed >> 2) & 1 ? true : false;
  301.     val.has_rts = (packed >> 3) & 1 ? true : false;
  302.     decoder.skip(1);
  303.     decoder.skip(1);
  304.     decoder.skip(1);
  305.     decoder.skip(1);
  306.     decoder.skip(1);
  307.     decoder.skip(1);
  308.     decoder.skip(1);
  309.     return val;
  310.   };
  311.  
  312.   HostControlSignals.encode = function(encoder, val) {
  313.     var packed;
  314.     encoder.writeUint32(HostControlSignals.encodedSize);
  315.     encoder.writeUint32(4);
  316.     packed = 0;
  317.     packed |= (val.dtr & 1) << 0
  318.     packed |= (val.has_dtr & 1) << 1
  319.     packed |= (val.rts & 1) << 2
  320.     packed |= (val.has_rts & 1) << 3
  321.     encoder.writeUint8(packed);
  322.     encoder.skip(1);
  323.     encoder.skip(1);
  324.     encoder.skip(1);
  325.     encoder.skip(1);
  326.     encoder.skip(1);
  327.     encoder.skip(1);
  328.     encoder.skip(1);
  329.   };
  330.  
  331.   function DeviceControlSignals(values) {
  332.     this.initDefaults_();
  333.     this.initFields_(values);
  334.   }
  335.  
  336.  
  337.   DeviceControlSignals.prototype.initDefaults_ = function() {
  338.     this.dcd = false;
  339.     this.cts = false;
  340.     this.ri = false;
  341.     this.dsr = false;
  342.   };
  343.   DeviceControlSignals.prototype.initFields_ = function(fields) {
  344.     for(var field in fields) {
  345.         if (this.hasOwnProperty(field))
  346.           this[field] = fields[field];
  347.     }
  348.   };
  349.  
  350.   DeviceControlSignals.validate = function(messageValidator, offset) {
  351.     var err;
  352.  
  353.     err = messageValidator.validateStructHeader(offset, DeviceControlSignals.encodedSize, 4);
  354.     if (err !== validator.validationError.NONE)
  355.         return err;
  356.  
  357.     return validator.validationError.NONE;
  358.   };
  359.  
  360.   DeviceControlSignals.encodedSize = codec.kStructHeaderSize + 8;
  361.  
  362.   DeviceControlSignals.decode = function(decoder) {
  363.     var packed;
  364.     var val = new DeviceControlSignals();
  365.     var numberOfBytes = decoder.readUint32();
  366.     var numberOfFields = decoder.readUint32();
  367.     packed = decoder.readUint8();
  368.     val.dcd = (packed >> 0) & 1 ? true : false;
  369.     val.cts = (packed >> 1) & 1 ? true : false;
  370.     val.ri = (packed >> 2) & 1 ? true : false;
  371.     val.dsr = (packed >> 3) & 1 ? true : false;
  372.     decoder.skip(1);
  373.     decoder.skip(1);
  374.     decoder.skip(1);
  375.     decoder.skip(1);
  376.     decoder.skip(1);
  377.     decoder.skip(1);
  378.     decoder.skip(1);
  379.     return val;
  380.   };
  381.  
  382.   DeviceControlSignals.encode = function(encoder, val) {
  383.     var packed;
  384.     encoder.writeUint32(DeviceControlSignals.encodedSize);
  385.     encoder.writeUint32(4);
  386.     packed = 0;
  387.     packed |= (val.dcd & 1) << 0
  388.     packed |= (val.cts & 1) << 1
  389.     packed |= (val.ri & 1) << 2
  390.     packed |= (val.dsr & 1) << 3
  391.     encoder.writeUint8(packed);
  392.     encoder.skip(1);
  393.     encoder.skip(1);
  394.     encoder.skip(1);
  395.     encoder.skip(1);
  396.     encoder.skip(1);
  397.     encoder.skip(1);
  398.     encoder.skip(1);
  399.   };
  400.  
  401.   function SerialService_GetDevices_Params(values) {
  402.     this.initDefaults_();
  403.     this.initFields_(values);
  404.   }
  405.  
  406.  
  407.   SerialService_GetDevices_Params.prototype.initDefaults_ = function() {
  408.   };
  409.   SerialService_GetDevices_Params.prototype.initFields_ = function(fields) {
  410.     for(var field in fields) {
  411.         if (this.hasOwnProperty(field))
  412.           this[field] = fields[field];
  413.     }
  414.   };
  415.  
  416.   SerialService_GetDevices_Params.validate = function(messageValidator, offset) {
  417.     var err;
  418.  
  419.     err = messageValidator.validateStructHeader(offset, SerialService_GetDevices_Params.encodedSize, 0);
  420.     if (err !== validator.validationError.NONE)
  421.         return err;
  422.  
  423.     return validator.validationError.NONE;
  424.   };
  425.  
  426.   SerialService_GetDevices_Params.encodedSize = codec.kStructHeaderSize + 0;
  427.  
  428.   SerialService_GetDevices_Params.decode = function(decoder) {
  429.     var packed;
  430.     var val = new SerialService_GetDevices_Params();
  431.     var numberOfBytes = decoder.readUint32();
  432.     var numberOfFields = decoder.readUint32();
  433.     return val;
  434.   };
  435.  
  436.   SerialService_GetDevices_Params.encode = function(encoder, val) {
  437.     var packed;
  438.     encoder.writeUint32(SerialService_GetDevices_Params.encodedSize);
  439.     encoder.writeUint32(0);
  440.   };
  441.  
  442.   function SerialService_GetDevices_ResponseParams(values) {
  443.     this.initDefaults_();
  444.     this.initFields_(values);
  445.   }
  446.  
  447.  
  448.   SerialService_GetDevices_ResponseParams.prototype.initDefaults_ = function() {
  449.     this.devices = null;
  450.   };
  451.   SerialService_GetDevices_ResponseParams.prototype.initFields_ = function(fields) {
  452.     for(var field in fields) {
  453.         if (this.hasOwnProperty(field))
  454.           this[field] = fields[field];
  455.     }
  456.   };
  457.  
  458.   SerialService_GetDevices_ResponseParams.validate = function(messageValidator, offset) {
  459.     var err;
  460.  
  461.     err = messageValidator.validateStructHeader(offset, SerialService_GetDevices_ResponseParams.encodedSize, 1);
  462.     if (err !== validator.validationError.NONE)
  463.         return err;
  464.     // validate SerialService_GetDevices_ResponseParams.devices
  465.     err = messageValidator.validateArrayPointer(offset + codec.kStructHeaderSize + 0, 8, new codec.PointerTo(DeviceInfo), false, [0], 0);
  466.     if (err !== validator.validationError.NONE)
  467.         return err;
  468.  
  469.     return validator.validationError.NONE;
  470.   };
  471.  
  472.   SerialService_GetDevices_ResponseParams.encodedSize = codec.kStructHeaderSize + 8;
  473.  
  474.   SerialService_GetDevices_ResponseParams.decode = function(decoder) {
  475.     var packed;
  476.     var val = new SerialService_GetDevices_ResponseParams();
  477.     var numberOfBytes = decoder.readUint32();
  478.     var numberOfFields = decoder.readUint32();
  479.     val.devices = decoder.decodeArrayPointer(new codec.PointerTo(DeviceInfo));
  480.     return val;
  481.   };
  482.  
  483.   SerialService_GetDevices_ResponseParams.encode = function(encoder, val) {
  484.     var packed;
  485.     encoder.writeUint32(SerialService_GetDevices_ResponseParams.encodedSize);
  486.     encoder.writeUint32(1);
  487.     encoder.encodeArrayPointer(new codec.PointerTo(DeviceInfo), val.devices);
  488.   };
  489.  
  490.   function SerialService_Connect_Params(values) {
  491.     this.initDefaults_();
  492.     this.initFields_(values);
  493.   }
  494.  
  495.  
  496.   SerialService_Connect_Params.prototype.initDefaults_ = function() {
  497.     this.path = null;
  498.     this.options = null;
  499.     this.connection = null;
  500.     this.sink = null;
  501.     this.source = null;
  502.   };
  503.   SerialService_Connect_Params.prototype.initFields_ = function(fields) {
  504.     for(var field in fields) {
  505.         if (this.hasOwnProperty(field))
  506.           this[field] = fields[field];
  507.     }
  508.   };
  509.  
  510.   SerialService_Connect_Params.validate = function(messageValidator, offset) {
  511.     var err;
  512.  
  513.     err = messageValidator.validateStructHeader(offset, SerialService_Connect_Params.encodedSize, 5);
  514.     if (err !== validator.validationError.NONE)
  515.         return err;
  516.     // validate SerialService_Connect_Params.path
  517.     err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 0, false)
  518.     if (err !== validator.validationError.NONE)
  519.         return err;
  520.     // validate SerialService_Connect_Params.options
  521.     err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 8, ConnectionOptions, true);
  522.     if (err !== validator.validationError.NONE)
  523.         return err;
  524.     // validate SerialService_Connect_Params.connection
  525.     err = messageValidator.validateHandle(offset + codec.kStructHeaderSize + 16, false)
  526.     if (err !== validator.validationError.NONE)
  527.         return err;
  528.     // validate SerialService_Connect_Params.sink
  529.     err = messageValidator.validateHandle(offset + codec.kStructHeaderSize + 20, false)
  530.     if (err !== validator.validationError.NONE)
  531.         return err;
  532.     // validate SerialService_Connect_Params.source
  533.     err = messageValidator.validateHandle(offset + codec.kStructHeaderSize + 24, false)
  534.     if (err !== validator.validationError.NONE)
  535.         return err;
  536.  
  537.     return validator.validationError.NONE;
  538.   };
  539.  
  540.   SerialService_Connect_Params.encodedSize = codec.kStructHeaderSize + 32;
  541.  
  542.   SerialService_Connect_Params.decode = function(decoder) {
  543.     var packed;
  544.     var val = new SerialService_Connect_Params();
  545.     var numberOfBytes = decoder.readUint32();
  546.     var numberOfFields = decoder.readUint32();
  547.     val.path = decoder.decodeStruct(codec.String);
  548.     val.options = decoder.decodeStructPointer(ConnectionOptions);
  549.     val.connection = decoder.decodeStruct(codec.Handle);
  550.     val.sink = decoder.decodeStruct(codec.Handle);
  551.     val.source = decoder.decodeStruct(codec.Handle);
  552.     decoder.skip(1);
  553.     decoder.skip(1);
  554.     decoder.skip(1);
  555.     decoder.skip(1);
  556.     return val;
  557.   };
  558.  
  559.   SerialService_Connect_Params.encode = function(encoder, val) {
  560.     var packed;
  561.     encoder.writeUint32(SerialService_Connect_Params.encodedSize);
  562.     encoder.writeUint32(5);
  563.     encoder.encodeStruct(codec.String, val.path);
  564.     encoder.encodeStructPointer(ConnectionOptions, val.options);
  565.     encoder.encodeStruct(codec.Handle, val.connection);
  566.     encoder.encodeStruct(codec.Handle, val.sink);
  567.     encoder.encodeStruct(codec.Handle, val.source);
  568.     encoder.skip(1);
  569.     encoder.skip(1);
  570.     encoder.skip(1);
  571.     encoder.skip(1);
  572.   };
  573.  
  574.   function Connection_GetInfo_Params(values) {
  575.     this.initDefaults_();
  576.     this.initFields_(values);
  577.   }
  578.  
  579.  
  580.   Connection_GetInfo_Params.prototype.initDefaults_ = function() {
  581.   };
  582.   Connection_GetInfo_Params.prototype.initFields_ = function(fields) {
  583.     for(var field in fields) {
  584.         if (this.hasOwnProperty(field))
  585.           this[field] = fields[field];
  586.     }
  587.   };
  588.  
  589.   Connection_GetInfo_Params.validate = function(messageValidator, offset) {
  590.     var err;
  591.  
  592.     err = messageValidator.validateStructHeader(offset, Connection_GetInfo_Params.encodedSize, 0);
  593.     if (err !== validator.validationError.NONE)
  594.         return err;
  595.  
  596.     return validator.validationError.NONE;
  597.   };
  598.  
  599.   Connection_GetInfo_Params.encodedSize = codec.kStructHeaderSize + 0;
  600.  
  601.   Connection_GetInfo_Params.decode = function(decoder) {
  602.     var packed;
  603.     var val = new Connection_GetInfo_Params();
  604.     var numberOfBytes = decoder.readUint32();
  605.     var numberOfFields = decoder.readUint32();
  606.     return val;
  607.   };
  608.  
  609.   Connection_GetInfo_Params.encode = function(encoder, val) {
  610.     var packed;
  611.     encoder.writeUint32(Connection_GetInfo_Params.encodedSize);
  612.     encoder.writeUint32(0);
  613.   };
  614.  
  615.   function Connection_GetInfo_ResponseParams(values) {
  616.     this.initDefaults_();
  617.     this.initFields_(values);
  618.   }
  619.  
  620.  
  621.   Connection_GetInfo_ResponseParams.prototype.initDefaults_ = function() {
  622.     this.info = null;
  623.   };
  624.   Connection_GetInfo_ResponseParams.prototype.initFields_ = function(fields) {
  625.     for(var field in fields) {
  626.         if (this.hasOwnProperty(field))
  627.           this[field] = fields[field];
  628.     }
  629.   };
  630.  
  631.   Connection_GetInfo_ResponseParams.validate = function(messageValidator, offset) {
  632.     var err;
  633.  
  634.     err = messageValidator.validateStructHeader(offset, Connection_GetInfo_ResponseParams.encodedSize, 1);
  635.     if (err !== validator.validationError.NONE)
  636.         return err;
  637.     // validate Connection_GetInfo_ResponseParams.info
  638.     err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, ConnectionInfo, true);
  639.     if (err !== validator.validationError.NONE)
  640.         return err;
  641.  
  642.     return validator.validationError.NONE;
  643.   };
  644.  
  645.   Connection_GetInfo_ResponseParams.encodedSize = codec.kStructHeaderSize + 8;
  646.  
  647.   Connection_GetInfo_ResponseParams.decode = function(decoder) {
  648.     var packed;
  649.     var val = new Connection_GetInfo_ResponseParams();
  650.     var numberOfBytes = decoder.readUint32();
  651.     var numberOfFields = decoder.readUint32();
  652.     val.info = decoder.decodeStructPointer(ConnectionInfo);
  653.     return val;
  654.   };
  655.  
  656.   Connection_GetInfo_ResponseParams.encode = function(encoder, val) {
  657.     var packed;
  658.     encoder.writeUint32(Connection_GetInfo_ResponseParams.encodedSize);
  659.     encoder.writeUint32(1);
  660.     encoder.encodeStructPointer(ConnectionInfo, val.info);
  661.   };
  662.  
  663.   function Connection_SetOptions_Params(values) {
  664.     this.initDefaults_();
  665.     this.initFields_(values);
  666.   }
  667.  
  668.  
  669.   Connection_SetOptions_Params.prototype.initDefaults_ = function() {
  670.     this.options = null;
  671.   };
  672.   Connection_SetOptions_Params.prototype.initFields_ = function(fields) {
  673.     for(var field in fields) {
  674.         if (this.hasOwnProperty(field))
  675.           this[field] = fields[field];
  676.     }
  677.   };
  678.  
  679.   Connection_SetOptions_Params.validate = function(messageValidator, offset) {
  680.     var err;
  681.  
  682.     err = messageValidator.validateStructHeader(offset, Connection_SetOptions_Params.encodedSize, 1);
  683.     if (err !== validator.validationError.NONE)
  684.         return err;
  685.     // validate Connection_SetOptions_Params.options
  686.     err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, ConnectionOptions, false);
  687.     if (err !== validator.validationError.NONE)
  688.         return err;
  689.  
  690.     return validator.validationError.NONE;
  691.   };
  692.  
  693.   Connection_SetOptions_Params.encodedSize = codec.kStructHeaderSize + 8;
  694.  
  695.   Connection_SetOptions_Params.decode = function(decoder) {
  696.     var packed;
  697.     var val = new Connection_SetOptions_Params();
  698.     var numberOfBytes = decoder.readUint32();
  699.     var numberOfFields = decoder.readUint32();
  700.     val.options = decoder.decodeStructPointer(ConnectionOptions);
  701.     return val;
  702.   };
  703.  
  704.   Connection_SetOptions_Params.encode = function(encoder, val) {
  705.     var packed;
  706.     encoder.writeUint32(Connection_SetOptions_Params.encodedSize);
  707.     encoder.writeUint32(1);
  708.     encoder.encodeStructPointer(ConnectionOptions, val.options);
  709.   };
  710.  
  711.   function Connection_SetOptions_ResponseParams(values) {
  712.     this.initDefaults_();
  713.     this.initFields_(values);
  714.   }
  715.  
  716.  
  717.   Connection_SetOptions_ResponseParams.prototype.initDefaults_ = function() {
  718.     this.success = false;
  719.   };
  720.   Connection_SetOptions_ResponseParams.prototype.initFields_ = function(fields) {
  721.     for(var field in fields) {
  722.         if (this.hasOwnProperty(field))
  723.           this[field] = fields[field];
  724.     }
  725.   };
  726.  
  727.   Connection_SetOptions_ResponseParams.validate = function(messageValidator, offset) {
  728.     var err;
  729.  
  730.     err = messageValidator.validateStructHeader(offset, Connection_SetOptions_ResponseParams.encodedSize, 1);
  731.     if (err !== validator.validationError.NONE)
  732.         return err;
  733.  
  734.     return validator.validationError.NONE;
  735.   };
  736.  
  737.   Connection_SetOptions_ResponseParams.encodedSize = codec.kStructHeaderSize + 8;
  738.  
  739.   Connection_SetOptions_ResponseParams.decode = function(decoder) {
  740.     var packed;
  741.     var val = new Connection_SetOptions_ResponseParams();
  742.     var numberOfBytes = decoder.readUint32();
  743.     var numberOfFields = decoder.readUint32();
  744.     val.success = decoder.decodeStruct(codec.Uint8);
  745.     decoder.skip(1);
  746.     decoder.skip(1);
  747.     decoder.skip(1);
  748.     decoder.skip(1);
  749.     decoder.skip(1);
  750.     decoder.skip(1);
  751.     decoder.skip(1);
  752.     return val;
  753.   };
  754.  
  755.   Connection_SetOptions_ResponseParams.encode = function(encoder, val) {
  756.     var packed;
  757.     encoder.writeUint32(Connection_SetOptions_ResponseParams.encodedSize);
  758.     encoder.writeUint32(1);
  759.     encoder.encodeStruct(codec.Uint8, val.success);
  760.     encoder.skip(1);
  761.     encoder.skip(1);
  762.     encoder.skip(1);
  763.     encoder.skip(1);
  764.     encoder.skip(1);
  765.     encoder.skip(1);
  766.     encoder.skip(1);
  767.   };
  768.  
  769.   function Connection_SetControlSignals_Params(values) {
  770.     this.initDefaults_();
  771.     this.initFields_(values);
  772.   }
  773.  
  774.  
  775.   Connection_SetControlSignals_Params.prototype.initDefaults_ = function() {
  776.     this.signals = null;
  777.   };
  778.   Connection_SetControlSignals_Params.prototype.initFields_ = function(fields) {
  779.     for(var field in fields) {
  780.         if (this.hasOwnProperty(field))
  781.           this[field] = fields[field];
  782.     }
  783.   };
  784.  
  785.   Connection_SetControlSignals_Params.validate = function(messageValidator, offset) {
  786.     var err;
  787.  
  788.     err = messageValidator.validateStructHeader(offset, Connection_SetControlSignals_Params.encodedSize, 1);
  789.     if (err !== validator.validationError.NONE)
  790.         return err;
  791.     // validate Connection_SetControlSignals_Params.signals
  792.     err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, HostControlSignals, false);
  793.     if (err !== validator.validationError.NONE)
  794.         return err;
  795.  
  796.     return validator.validationError.NONE;
  797.   };
  798.  
  799.   Connection_SetControlSignals_Params.encodedSize = codec.kStructHeaderSize + 8;
  800.  
  801.   Connection_SetControlSignals_Params.decode = function(decoder) {
  802.     var packed;
  803.     var val = new Connection_SetControlSignals_Params();
  804.     var numberOfBytes = decoder.readUint32();
  805.     var numberOfFields = decoder.readUint32();
  806.     val.signals = decoder.decodeStructPointer(HostControlSignals);
  807.     return val;
  808.   };
  809.  
  810.   Connection_SetControlSignals_Params.encode = function(encoder, val) {
  811.     var packed;
  812.     encoder.writeUint32(Connection_SetControlSignals_Params.encodedSize);
  813.     encoder.writeUint32(1);
  814.     encoder.encodeStructPointer(HostControlSignals, val.signals);
  815.   };
  816.  
  817.   function Connection_SetControlSignals_ResponseParams(values) {
  818.     this.initDefaults_();
  819.     this.initFields_(values);
  820.   }
  821.  
  822.  
  823.   Connection_SetControlSignals_ResponseParams.prototype.initDefaults_ = function() {
  824.     this.success = false;
  825.   };
  826.   Connection_SetControlSignals_ResponseParams.prototype.initFields_ = function(fields) {
  827.     for(var field in fields) {
  828.         if (this.hasOwnProperty(field))
  829.           this[field] = fields[field];
  830.     }
  831.   };
  832.  
  833.   Connection_SetControlSignals_ResponseParams.validate = function(messageValidator, offset) {
  834.     var err;
  835.  
  836.     err = messageValidator.validateStructHeader(offset, Connection_SetControlSignals_ResponseParams.encodedSize, 1);
  837.     if (err !== validator.validationError.NONE)
  838.         return err;
  839.  
  840.     return validator.validationError.NONE;
  841.   };
  842.  
  843.   Connection_SetControlSignals_ResponseParams.encodedSize = codec.kStructHeaderSize + 8;
  844.  
  845.   Connection_SetControlSignals_ResponseParams.decode = function(decoder) {
  846.     var packed;
  847.     var val = new Connection_SetControlSignals_ResponseParams();
  848.     var numberOfBytes = decoder.readUint32();
  849.     var numberOfFields = decoder.readUint32();
  850.     val.success = decoder.decodeStruct(codec.Uint8);
  851.     decoder.skip(1);
  852.     decoder.skip(1);
  853.     decoder.skip(1);
  854.     decoder.skip(1);
  855.     decoder.skip(1);
  856.     decoder.skip(1);
  857.     decoder.skip(1);
  858.     return val;
  859.   };
  860.  
  861.   Connection_SetControlSignals_ResponseParams.encode = function(encoder, val) {
  862.     var packed;
  863.     encoder.writeUint32(Connection_SetControlSignals_ResponseParams.encodedSize);
  864.     encoder.writeUint32(1);
  865.     encoder.encodeStruct(codec.Uint8, val.success);
  866.     encoder.skip(1);
  867.     encoder.skip(1);
  868.     encoder.skip(1);
  869.     encoder.skip(1);
  870.     encoder.skip(1);
  871.     encoder.skip(1);
  872.     encoder.skip(1);
  873.   };
  874.  
  875.   function Connection_GetControlSignals_Params(values) {
  876.     this.initDefaults_();
  877.     this.initFields_(values);
  878.   }
  879.  
  880.  
  881.   Connection_GetControlSignals_Params.prototype.initDefaults_ = function() {
  882.   };
  883.   Connection_GetControlSignals_Params.prototype.initFields_ = function(fields) {
  884.     for(var field in fields) {
  885.         if (this.hasOwnProperty(field))
  886.           this[field] = fields[field];
  887.     }
  888.   };
  889.  
  890.   Connection_GetControlSignals_Params.validate = function(messageValidator, offset) {
  891.     var err;
  892.  
  893.     err = messageValidator.validateStructHeader(offset, Connection_GetControlSignals_Params.encodedSize, 0);
  894.     if (err !== validator.validationError.NONE)
  895.         return err;
  896.  
  897.     return validator.validationError.NONE;
  898.   };
  899.  
  900.   Connection_GetControlSignals_Params.encodedSize = codec.kStructHeaderSize + 0;
  901.  
  902.   Connection_GetControlSignals_Params.decode = function(decoder) {
  903.     var packed;
  904.     var val = new Connection_GetControlSignals_Params();
  905.     var numberOfBytes = decoder.readUint32();
  906.     var numberOfFields = decoder.readUint32();
  907.     return val;
  908.   };
  909.  
  910.   Connection_GetControlSignals_Params.encode = function(encoder, val) {
  911.     var packed;
  912.     encoder.writeUint32(Connection_GetControlSignals_Params.encodedSize);
  913.     encoder.writeUint32(0);
  914.   };
  915.  
  916.   function Connection_GetControlSignals_ResponseParams(values) {
  917.     this.initDefaults_();
  918.     this.initFields_(values);
  919.   }
  920.  
  921.  
  922.   Connection_GetControlSignals_ResponseParams.prototype.initDefaults_ = function() {
  923.     this.signals = null;
  924.   };
  925.   Connection_GetControlSignals_ResponseParams.prototype.initFields_ = function(fields) {
  926.     for(var field in fields) {
  927.         if (this.hasOwnProperty(field))
  928.           this[field] = fields[field];
  929.     }
  930.   };
  931.  
  932.   Connection_GetControlSignals_ResponseParams.validate = function(messageValidator, offset) {
  933.     var err;
  934.  
  935.     err = messageValidator.validateStructHeader(offset, Connection_GetControlSignals_ResponseParams.encodedSize, 1);
  936.     if (err !== validator.validationError.NONE)
  937.         return err;
  938.     // validate Connection_GetControlSignals_ResponseParams.signals
  939.     err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, DeviceControlSignals, true);
  940.     if (err !== validator.validationError.NONE)
  941.         return err;
  942.  
  943.     return validator.validationError.NONE;
  944.   };
  945.  
  946.   Connection_GetControlSignals_ResponseParams.encodedSize = codec.kStructHeaderSize + 8;
  947.  
  948.   Connection_GetControlSignals_ResponseParams.decode = function(decoder) {
  949.     var packed;
  950.     var val = new Connection_GetControlSignals_ResponseParams();
  951.     var numberOfBytes = decoder.readUint32();
  952.     var numberOfFields = decoder.readUint32();
  953.     val.signals = decoder.decodeStructPointer(DeviceControlSignals);
  954.     return val;
  955.   };
  956.  
  957.   Connection_GetControlSignals_ResponseParams.encode = function(encoder, val) {
  958.     var packed;
  959.     encoder.writeUint32(Connection_GetControlSignals_ResponseParams.encodedSize);
  960.     encoder.writeUint32(1);
  961.     encoder.encodeStructPointer(DeviceControlSignals, val.signals);
  962.   };
  963.  
  964.   function Connection_Flush_Params(values) {
  965.     this.initDefaults_();
  966.     this.initFields_(values);
  967.   }
  968.  
  969.  
  970.   Connection_Flush_Params.prototype.initDefaults_ = function() {
  971.   };
  972.   Connection_Flush_Params.prototype.initFields_ = function(fields) {
  973.     for(var field in fields) {
  974.         if (this.hasOwnProperty(field))
  975.           this[field] = fields[field];
  976.     }
  977.   };
  978.  
  979.   Connection_Flush_Params.validate = function(messageValidator, offset) {
  980.     var err;
  981.  
  982.     err = messageValidator.validateStructHeader(offset, Connection_Flush_Params.encodedSize, 0);
  983.     if (err !== validator.validationError.NONE)
  984.         return err;
  985.  
  986.     return validator.validationError.NONE;
  987.   };
  988.  
  989.   Connection_Flush_Params.encodedSize = codec.kStructHeaderSize + 0;
  990.  
  991.   Connection_Flush_Params.decode = function(decoder) {
  992.     var packed;
  993.     var val = new Connection_Flush_Params();
  994.     var numberOfBytes = decoder.readUint32();
  995.     var numberOfFields = decoder.readUint32();
  996.     return val;
  997.   };
  998.  
  999.   Connection_Flush_Params.encode = function(encoder, val) {
  1000.     var packed;
  1001.     encoder.writeUint32(Connection_Flush_Params.encodedSize);
  1002.     encoder.writeUint32(0);
  1003.   };
  1004.  
  1005.   function Connection_Flush_ResponseParams(values) {
  1006.     this.initDefaults_();
  1007.     this.initFields_(values);
  1008.   }
  1009.  
  1010.  
  1011.   Connection_Flush_ResponseParams.prototype.initDefaults_ = function() {
  1012.     this.success = false;
  1013.   };
  1014.   Connection_Flush_ResponseParams.prototype.initFields_ = function(fields) {
  1015.     for(var field in fields) {
  1016.         if (this.hasOwnProperty(field))
  1017.           this[field] = fields[field];
  1018.     }
  1019.   };
  1020.  
  1021.   Connection_Flush_ResponseParams.validate = function(messageValidator, offset) {
  1022.     var err;
  1023.  
  1024.     err = messageValidator.validateStructHeader(offset, Connection_Flush_ResponseParams.encodedSize, 1);
  1025.     if (err !== validator.validationError.NONE)
  1026.         return err;
  1027.  
  1028.     return validator.validationError.NONE;
  1029.   };
  1030.  
  1031.   Connection_Flush_ResponseParams.encodedSize = codec.kStructHeaderSize + 8;
  1032.  
  1033.   Connection_Flush_ResponseParams.decode = function(decoder) {
  1034.     var packed;
  1035.     var val = new Connection_Flush_ResponseParams();
  1036.     var numberOfBytes = decoder.readUint32();
  1037.     var numberOfFields = decoder.readUint32();
  1038.     val.success = decoder.decodeStruct(codec.Uint8);
  1039.     decoder.skip(1);
  1040.     decoder.skip(1);
  1041.     decoder.skip(1);
  1042.     decoder.skip(1);
  1043.     decoder.skip(1);
  1044.     decoder.skip(1);
  1045.     decoder.skip(1);
  1046.     return val;
  1047.   };
  1048.  
  1049.   Connection_Flush_ResponseParams.encode = function(encoder, val) {
  1050.     var packed;
  1051.     encoder.writeUint32(Connection_Flush_ResponseParams.encodedSize);
  1052.     encoder.writeUint32(1);
  1053.     encoder.encodeStruct(codec.Uint8, val.success);
  1054.     encoder.skip(1);
  1055.     encoder.skip(1);
  1056.     encoder.skip(1);
  1057.     encoder.skip(1);
  1058.     encoder.skip(1);
  1059.     encoder.skip(1);
  1060.     encoder.skip(1);
  1061.   };
  1062.  
  1063.   var kSerialService_GetDevices_Name = 0;
  1064.   var kSerialService_Connect_Name = 1;
  1065.  
  1066.   function SerialServiceProxy(receiver) {
  1067.     bindings.ProxyBase.call(this, receiver);
  1068.   }
  1069.   SerialServiceProxy.prototype = Object.create(bindings.ProxyBase.prototype);
  1070.   SerialServiceProxy.prototype.getDevices = function() {
  1071.     var params = new SerialService_GetDevices_Params();
  1072.     return new Promise(function(resolve, reject) {
  1073.       var builder = new codec.MessageWithRequestIDBuilder(
  1074.           kSerialService_GetDevices_Name,
  1075.           codec.align(SerialService_GetDevices_Params.encodedSize),
  1076.           codec.kMessageExpectsResponse, 0);
  1077.       builder.encodeStruct(SerialService_GetDevices_Params, params);
  1078.       var message = builder.finish();
  1079.       this.receiver_.acceptAndExpectResponse(message).then(function(message) {
  1080.         var reader = new codec.MessageReader(message);
  1081.         var responseParams =
  1082.             reader.decodeStruct(SerialService_GetDevices_ResponseParams);
  1083.         resolve(responseParams);
  1084.       }).catch(function(result) {
  1085.         reject(Error("Connection error: " + result));
  1086.       });
  1087.     }.bind(this));
  1088.   };
  1089.   SerialServiceProxy.prototype.connect = function(path, options, connection, sink, source) {
  1090.     var params = new SerialService_Connect_Params();
  1091.     params.path = path;
  1092.     params.options = options;
  1093.     params.connection = core.isHandle(connection) ? connection : connection.bindProxyClient(connection, Connection.client, Connection);
  1094.     params.sink = core.isHandle(sink) ? sink : connection.bindProxyClient(sink, data_stream.DataSink.client, data_stream.DataSink);
  1095.     params.source = core.isHandle(source) ? source : connection.bindProxyClient(source, data_stream.DataSource.client, data_stream.DataSource);
  1096.     var builder = new codec.MessageBuilder(
  1097.         kSerialService_Connect_Name,
  1098.         codec.align(SerialService_Connect_Params.encodedSize));
  1099.     builder.encodeStruct(SerialService_Connect_Params, params);
  1100.     var message = builder.finish();
  1101.     this.receiver_.accept(message);
  1102.   };
  1103.  
  1104.   function SerialServiceStub(delegate) {
  1105.     bindings.StubBase.call(this, delegate);
  1106.   }
  1107.   SerialServiceStub.prototype = Object.create(bindings.StubBase.prototype);
  1108.   SerialServiceStub.prototype.getDevices = function() {
  1109.     return bindings.StubBindings(this).delegate && bindings.StubBindings(this).delegate.getDevices && bindings.StubBindings(this).delegate.getDevices();
  1110.   }
  1111.   SerialServiceStub.prototype.connect = function(path, options, connection, sink, source) {
  1112.     return bindings.StubBindings(this).delegate && bindings.StubBindings(this).delegate.connect && bindings.StubBindings(this).delegate.connect(path, options, connection.bindProxyHandle(connection, Connection, Connection.client), connection.bindProxyHandle(sink, data_stream.DataSink, data_stream.DataSink.client), connection.bindProxyHandle(source, data_stream.DataSource, data_stream.DataSource.client));
  1113.   }
  1114.  
  1115.   SerialServiceStub.prototype.accept = function(message) {
  1116.     var reader = new codec.MessageReader(message);
  1117.     switch (reader.messageName) {
  1118.     case kSerialService_Connect_Name:
  1119.       var params = reader.decodeStruct(SerialService_Connect_Params);
  1120.       this.connect(params.path, params.options, params.connection, params.sink, params.source);
  1121.       return true;
  1122.     default:
  1123.       return false;
  1124.     }
  1125.   };
  1126.  
  1127.   SerialServiceStub.prototype.acceptWithResponder =
  1128.       function(message, responder) {
  1129.     var reader = new codec.MessageReader(message);
  1130.     switch (reader.messageName) {
  1131.     case kSerialService_GetDevices_Name:
  1132.       var params = reader.decodeStruct(SerialService_GetDevices_Params);
  1133.       return this.getDevices().then(function(response) {
  1134.         var responseParams =
  1135.             new SerialService_GetDevices_ResponseParams();
  1136.         responseParams.devices = response.devices;
  1137.         var builder = new codec.MessageWithRequestIDBuilder(
  1138.             kSerialService_GetDevices_Name,
  1139.             codec.align(SerialService_GetDevices_ResponseParams.encodedSize),
  1140.             codec.kMessageIsResponse, reader.requestID);
  1141.         builder.encodeStruct(SerialService_GetDevices_ResponseParams,
  1142.                              responseParams);
  1143.         var message = builder.finish();
  1144.         responder.accept(message);
  1145.       });
  1146.     default:
  1147.       return Promise.reject(Error("Unhandled message: " + reader.messageName));
  1148.     }
  1149.   };
  1150.  
  1151.   function validateSerialServiceRequest(messageValidator) {
  1152.     var message = messageValidator.message;
  1153.     var paramsClass = null;
  1154.     switch (message.getName()) {
  1155.       case kSerialService_GetDevices_Name:
  1156.         if (message.expectsResponse())
  1157.           paramsClass = SerialService_GetDevices_Params;
  1158.       break;
  1159.       case kSerialService_Connect_Name:
  1160.         if (!message.expectsResponse() && !message.isResponse())
  1161.           paramsClass = SerialService_Connect_Params;
  1162.       break;
  1163.     }
  1164.     if (paramsClass === null)
  1165.       return validator.validationError.NONE;
  1166.     return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes());
  1167.   }
  1168.  
  1169.   function validateSerialServiceResponse(messageValidator) {
  1170.    var message = messageValidator.message;
  1171.    var paramsClass = null;
  1172.    switch (message.getName()) {
  1173.       case kSerialService_GetDevices_Name:
  1174.         if (message.isResponse())
  1175.           paramsClass = SerialService_GetDevices_ResponseParams;
  1176.         break;
  1177.     }
  1178.     if (paramsClass === null)
  1179.       return validator.validationError.NONE;
  1180.     return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes());
  1181.   }
  1182.  
  1183.   var SerialService = {
  1184.     name: 'device::serial::SerialService',
  1185.     proxyClass: SerialServiceProxy,
  1186.     stubClass: SerialServiceStub,
  1187.     validateRequest: validateSerialServiceRequest,
  1188.     validateResponse: validateSerialServiceResponse,
  1189.   };
  1190.   SerialServiceStub.prototype.validator = validateSerialServiceRequest;
  1191.   SerialServiceProxy.prototype.validator = validateSerialServiceResponse;
  1192.  
  1193.   var kConnection_GetInfo_Name = 0;
  1194.   var kConnection_SetOptions_Name = 1;
  1195.   var kConnection_SetControlSignals_Name = 2;
  1196.   var kConnection_GetControlSignals_Name = 3;
  1197.   var kConnection_Flush_Name = 4;
  1198.  
  1199.   function ConnectionProxy(receiver) {
  1200.     bindings.ProxyBase.call(this, receiver);
  1201.   }
  1202.   ConnectionProxy.prototype = Object.create(bindings.ProxyBase.prototype);
  1203.   ConnectionProxy.prototype.getInfo = function() {
  1204.     var params = new Connection_GetInfo_Params();
  1205.     return new Promise(function(resolve, reject) {
  1206.       var builder = new codec.MessageWithRequestIDBuilder(
  1207.           kConnection_GetInfo_Name,
  1208.           codec.align(Connection_GetInfo_Params.encodedSize),
  1209.           codec.kMessageExpectsResponse, 0);
  1210.       builder.encodeStruct(Connection_GetInfo_Params, params);
  1211.       var message = builder.finish();
  1212.       this.receiver_.acceptAndExpectResponse(message).then(function(message) {
  1213.         var reader = new codec.MessageReader(message);
  1214.         var responseParams =
  1215.             reader.decodeStruct(Connection_GetInfo_ResponseParams);
  1216.         resolve(responseParams);
  1217.       }).catch(function(result) {
  1218.         reject(Error("Connection error: " + result));
  1219.       });
  1220.     }.bind(this));
  1221.   };
  1222.   ConnectionProxy.prototype.setOptions = function(options) {
  1223.     var params = new Connection_SetOptions_Params();
  1224.     params.options = options;
  1225.     return new Promise(function(resolve, reject) {
  1226.       var builder = new codec.MessageWithRequestIDBuilder(
  1227.           kConnection_SetOptions_Name,
  1228.           codec.align(Connection_SetOptions_Params.encodedSize),
  1229.           codec.kMessageExpectsResponse, 0);
  1230.       builder.encodeStruct(Connection_SetOptions_Params, params);
  1231.       var message = builder.finish();
  1232.       this.receiver_.acceptAndExpectResponse(message).then(function(message) {
  1233.         var reader = new codec.MessageReader(message);
  1234.         var responseParams =
  1235.             reader.decodeStruct(Connection_SetOptions_ResponseParams);
  1236.         resolve(responseParams);
  1237.       }).catch(function(result) {
  1238.         reject(Error("Connection error: " + result));
  1239.       });
  1240.     }.bind(this));
  1241.   };
  1242.   ConnectionProxy.prototype.setControlSignals = function(signals) {
  1243.     var params = new Connection_SetControlSignals_Params();
  1244.     params.signals = signals;
  1245.     return new Promise(function(resolve, reject) {
  1246.       var builder = new codec.MessageWithRequestIDBuilder(
  1247.           kConnection_SetControlSignals_Name,
  1248.           codec.align(Connection_SetControlSignals_Params.encodedSize),
  1249.           codec.kMessageExpectsResponse, 0);
  1250.       builder.encodeStruct(Connection_SetControlSignals_Params, params);
  1251.       var message = builder.finish();
  1252.       this.receiver_.acceptAndExpectResponse(message).then(function(message) {
  1253.         var reader = new codec.MessageReader(message);
  1254.         var responseParams =
  1255.             reader.decodeStruct(Connection_SetControlSignals_ResponseParams);
  1256.         resolve(responseParams);
  1257.       }).catch(function(result) {
  1258.         reject(Error("Connection error: " + result));
  1259.       });
  1260.     }.bind(this));
  1261.   };
  1262.   ConnectionProxy.prototype.getControlSignals = function() {
  1263.     var params = new Connection_GetControlSignals_Params();
  1264.     return new Promise(function(resolve, reject) {
  1265.       var builder = new codec.MessageWithRequestIDBuilder(
  1266.           kConnection_GetControlSignals_Name,
  1267.           codec.align(Connection_GetControlSignals_Params.encodedSize),
  1268.           codec.kMessageExpectsResponse, 0);
  1269.       builder.encodeStruct(Connection_GetControlSignals_Params, params);
  1270.       var message = builder.finish();
  1271.       this.receiver_.acceptAndExpectResponse(message).then(function(message) {
  1272.         var reader = new codec.MessageReader(message);
  1273.         var responseParams =
  1274.             reader.decodeStruct(Connection_GetControlSignals_ResponseParams);
  1275.         resolve(responseParams);
  1276.       }).catch(function(result) {
  1277.         reject(Error("Connection error: " + result));
  1278.       });
  1279.     }.bind(this));
  1280.   };
  1281.   ConnectionProxy.prototype.flush = function() {
  1282.     var params = new Connection_Flush_Params();
  1283.     return new Promise(function(resolve, reject) {
  1284.       var builder = new codec.MessageWithRequestIDBuilder(
  1285.           kConnection_Flush_Name,
  1286.           codec.align(Connection_Flush_Params.encodedSize),
  1287.           codec.kMessageExpectsResponse, 0);
  1288.       builder.encodeStruct(Connection_Flush_Params, params);
  1289.       var message = builder.finish();
  1290.       this.receiver_.acceptAndExpectResponse(message).then(function(message) {
  1291.         var reader = new codec.MessageReader(message);
  1292.         var responseParams =
  1293.             reader.decodeStruct(Connection_Flush_ResponseParams);
  1294.         resolve(responseParams);
  1295.       }).catch(function(result) {
  1296.         reject(Error("Connection error: " + result));
  1297.       });
  1298.     }.bind(this));
  1299.   };
  1300.  
  1301.   function ConnectionStub(delegate) {
  1302.     bindings.StubBase.call(this, delegate);
  1303.   }
  1304.   ConnectionStub.prototype = Object.create(bindings.StubBase.prototype);
  1305.   ConnectionStub.prototype.getInfo = function() {
  1306.     return bindings.StubBindings(this).delegate && bindings.StubBindings(this).delegate.getInfo && bindings.StubBindings(this).delegate.getInfo();
  1307.   }
  1308.   ConnectionStub.prototype.setOptions = function(options) {
  1309.     return bindings.StubBindings(this).delegate && bindings.StubBindings(this).delegate.setOptions && bindings.StubBindings(this).delegate.setOptions(options);
  1310.   }
  1311.   ConnectionStub.prototype.setControlSignals = function(signals) {
  1312.     return bindings.StubBindings(this).delegate && bindings.StubBindings(this).delegate.setControlSignals && bindings.StubBindings(this).delegate.setControlSignals(signals);
  1313.   }
  1314.   ConnectionStub.prototype.getControlSignals = function() {
  1315.     return bindings.StubBindings(this).delegate && bindings.StubBindings(this).delegate.getControlSignals && bindings.StubBindings(this).delegate.getControlSignals();
  1316.   }
  1317.   ConnectionStub.prototype.flush = function() {
  1318.     return bindings.StubBindings(this).delegate && bindings.StubBindings(this).delegate.flush && bindings.StubBindings(this).delegate.flush();
  1319.   }
  1320.  
  1321.   ConnectionStub.prototype.accept = function(message) {
  1322.     var reader = new codec.MessageReader(message);
  1323.     switch (reader.messageName) {
  1324.     default:
  1325.       return false;
  1326.     }
  1327.   };
  1328.  
  1329.   ConnectionStub.prototype.acceptWithResponder =
  1330.       function(message, responder) {
  1331.     var reader = new codec.MessageReader(message);
  1332.     switch (reader.messageName) {
  1333.     case kConnection_GetInfo_Name:
  1334.       var params = reader.decodeStruct(Connection_GetInfo_Params);
  1335.       return this.getInfo().then(function(response) {
  1336.         var responseParams =
  1337.             new Connection_GetInfo_ResponseParams();
  1338.         responseParams.info = response.info;
  1339.         var builder = new codec.MessageWithRequestIDBuilder(
  1340.             kConnection_GetInfo_Name,
  1341.             codec.align(Connection_GetInfo_ResponseParams.encodedSize),
  1342.             codec.kMessageIsResponse, reader.requestID);
  1343.         builder.encodeStruct(Connection_GetInfo_ResponseParams,
  1344.                              responseParams);
  1345.         var message = builder.finish();
  1346.         responder.accept(message);
  1347.       });
  1348.     case kConnection_SetOptions_Name:
  1349.       var params = reader.decodeStruct(Connection_SetOptions_Params);
  1350.       return this.setOptions(params.options).then(function(response) {
  1351.         var responseParams =
  1352.             new Connection_SetOptions_ResponseParams();
  1353.         responseParams.success = response.success;
  1354.         var builder = new codec.MessageWithRequestIDBuilder(
  1355.             kConnection_SetOptions_Name,
  1356.             codec.align(Connection_SetOptions_ResponseParams.encodedSize),
  1357.             codec.kMessageIsResponse, reader.requestID);
  1358.         builder.encodeStruct(Connection_SetOptions_ResponseParams,
  1359.                              responseParams);
  1360.         var message = builder.finish();
  1361.         responder.accept(message);
  1362.       });
  1363.     case kConnection_SetControlSignals_Name:
  1364.       var params = reader.decodeStruct(Connection_SetControlSignals_Params);
  1365.       return this.setControlSignals(params.signals).then(function(response) {
  1366.         var responseParams =
  1367.             new Connection_SetControlSignals_ResponseParams();
  1368.         responseParams.success = response.success;
  1369.         var builder = new codec.MessageWithRequestIDBuilder(
  1370.             kConnection_SetControlSignals_Name,
  1371.             codec.align(Connection_SetControlSignals_ResponseParams.encodedSize),
  1372.             codec.kMessageIsResponse, reader.requestID);
  1373.         builder.encodeStruct(Connection_SetControlSignals_ResponseParams,
  1374.                              responseParams);
  1375.         var message = builder.finish();
  1376.         responder.accept(message);
  1377.       });
  1378.     case kConnection_GetControlSignals_Name:
  1379.       var params = reader.decodeStruct(Connection_GetControlSignals_Params);
  1380.       return this.getControlSignals().then(function(response) {
  1381.         var responseParams =
  1382.             new Connection_GetControlSignals_ResponseParams();
  1383.         responseParams.signals = response.signals;
  1384.         var builder = new codec.MessageWithRequestIDBuilder(
  1385.             kConnection_GetControlSignals_Name,
  1386.             codec.align(Connection_GetControlSignals_ResponseParams.encodedSize),
  1387.             codec.kMessageIsResponse, reader.requestID);
  1388.         builder.encodeStruct(Connection_GetControlSignals_ResponseParams,
  1389.                              responseParams);
  1390.         var message = builder.finish();
  1391.         responder.accept(message);
  1392.       });
  1393.     case kConnection_Flush_Name:
  1394.       var params = reader.decodeStruct(Connection_Flush_Params);
  1395.       return this.flush().then(function(response) {
  1396.         var responseParams =
  1397.             new Connection_Flush_ResponseParams();
  1398.         responseParams.success = response.success;
  1399.         var builder = new codec.MessageWithRequestIDBuilder(
  1400.             kConnection_Flush_Name,
  1401.             codec.align(Connection_Flush_ResponseParams.encodedSize),
  1402.             codec.kMessageIsResponse, reader.requestID);
  1403.         builder.encodeStruct(Connection_Flush_ResponseParams,
  1404.                              responseParams);
  1405.         var message = builder.finish();
  1406.         responder.accept(message);
  1407.       });
  1408.     default:
  1409.       return Promise.reject(Error("Unhandled message: " + reader.messageName));
  1410.     }
  1411.   };
  1412.  
  1413.   function validateConnectionRequest(messageValidator) {
  1414.     var message = messageValidator.message;
  1415.     var paramsClass = null;
  1416.     switch (message.getName()) {
  1417.       case kConnection_GetInfo_Name:
  1418.         if (message.expectsResponse())
  1419.           paramsClass = Connection_GetInfo_Params;
  1420.       break;
  1421.       case kConnection_SetOptions_Name:
  1422.         if (message.expectsResponse())
  1423.           paramsClass = Connection_SetOptions_Params;
  1424.       break;
  1425.       case kConnection_SetControlSignals_Name:
  1426.         if (message.expectsResponse())
  1427.           paramsClass = Connection_SetControlSignals_Params;
  1428.       break;
  1429.       case kConnection_GetControlSignals_Name:
  1430.         if (message.expectsResponse())
  1431.           paramsClass = Connection_GetControlSignals_Params;
  1432.       break;
  1433.       case kConnection_Flush_Name:
  1434.         if (message.expectsResponse())
  1435.           paramsClass = Connection_Flush_Params;
  1436.       break;
  1437.     }
  1438.     if (paramsClass === null)
  1439.       return validator.validationError.NONE;
  1440.     return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes());
  1441.   }
  1442.  
  1443.   function validateConnectionResponse(messageValidator) {
  1444.    var message = messageValidator.message;
  1445.    var paramsClass = null;
  1446.    switch (message.getName()) {
  1447.       case kConnection_GetInfo_Name:
  1448.         if (message.isResponse())
  1449.           paramsClass = Connection_GetInfo_ResponseParams;
  1450.         break;
  1451.       case kConnection_SetOptions_Name:
  1452.         if (message.isResponse())
  1453.           paramsClass = Connection_SetOptions_ResponseParams;
  1454.         break;
  1455.       case kConnection_SetControlSignals_Name:
  1456.         if (message.isResponse())
  1457.           paramsClass = Connection_SetControlSignals_ResponseParams;
  1458.         break;
  1459.       case kConnection_GetControlSignals_Name:
  1460.         if (message.isResponse())
  1461.           paramsClass = Connection_GetControlSignals_ResponseParams;
  1462.         break;
  1463.       case kConnection_Flush_Name:
  1464.         if (message.isResponse())
  1465.           paramsClass = Connection_Flush_ResponseParams;
  1466.         break;
  1467.     }
  1468.     if (paramsClass === null)
  1469.       return validator.validationError.NONE;
  1470.     return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes());
  1471.   }
  1472.  
  1473.   var Connection = {
  1474.     name: 'device::serial::Connection',
  1475.     proxyClass: ConnectionProxy,
  1476.     stubClass: ConnectionStub,
  1477.     validateRequest: validateConnectionRequest,
  1478.     validateResponse: validateConnectionResponse,
  1479.   };
  1480.   ConnectionStub.prototype.validator = validateConnectionRequest;
  1481.   ConnectionProxy.prototype.validator = validateConnectionResponse;
  1482.  
  1483.  
  1484.   var exports = {};
  1485.   exports.SendError = SendError;
  1486.   exports.ReceiveError = ReceiveError;
  1487.   exports.DataBits = DataBits;
  1488.   exports.ParityBit = ParityBit;
  1489.   exports.StopBits = StopBits;
  1490.   exports.DeviceInfo = DeviceInfo;
  1491.   exports.ConnectionOptions = ConnectionOptions;
  1492.   exports.ConnectionInfo = ConnectionInfo;
  1493.   exports.HostControlSignals = HostControlSignals;
  1494.   exports.DeviceControlSignals = DeviceControlSignals;
  1495.   exports.SerialService = SerialService;
  1496.   exports.Connection = Connection;
  1497.  
  1498.  
  1499.   return exports;
  1500. });
  1501.